.TH std::ranges::is_sorted 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::ranges::is_sorted \- std::ranges::is_sorted

.SH Synopsis
   Defined in header <algorithm>
   Call signature
   template< std::forward_iterator I, std::sentinel_for<I> S,

             class Proj = std::identity,
             std::indirect_strict_weak_order<std::projected<I, Proj>> \fB(1)\fP \fI(since C++20)\fP
                 Comp = ranges::less >
   constexpr bool

       is_sorted( I first, S last, Comp comp = {}, Proj proj = {} );
   template< ranges::forward_range R, class Proj = std::identity,

             std::indirect_strict_weak_order<
                 std::projected<ranges::iterator_t<R>, Proj>>         \fB(2)\fP \fI(since C++20)\fP
                     Comp = ranges::less >
   constexpr bool

       is_sorted( R&& r, Comp comp = {}, Proj proj = {} );

   Checks if the elements in range [first, last) are sorted in non-descending order.

   A sequence is sorted with respect to a comparator comp if for any iterator it
   pointing to the sequence and any non-negative integer n such that it + n is a valid
   iterator pointing to an element of the sequence, std::invoke(comp, std::invoke(proj,
   *(it + n)), std::invoke(proj, *it)) evaluates to false.

   1) Elements are compared using the given binary comparison function comp.
   2) Same as \fB(1)\fP, but uses r as the source range, as if using ranges::begin(r) as
   first and ranges::end(r) as last.

   The function-like entities described on this page are niebloids, that is:

     * Explicit template argument lists cannot be specified when calling any of them.
     * None of them are visible to argument-dependent lookup.
     * When any of them are found by normal unqualified lookup as the name to the left
       of the function-call operator, argument-dependent lookup is inhibited.

   In practice, they may be implemented as function objects, or with special compiler
   extensions.

.SH Parameters

   first, last - iterator-sentinel defining the range to check if it is sorted
   r           - the range to check if it is sorted
   comp        - comparison function to apply to the projected elements
   proj        - projection to apply to the elements

.SH Return value

   true if the elements in the range are sorted according to comp.

.SH Complexity

   Linear in the distance between first and last.

.SH Possible implementation

 struct is_sorted_fn
 {
     template<std::forward_iterator I, std::sentinel_for<I> S,
              class Proj = std::identity,
              std::indirect_strict_weak_order<std::projected<I, Proj>>
                  Comp = ranges::less>
     constexpr bool operator()(I first, S last, Comp comp = {}, Proj proj = {}) const
     {
         return ranges::is_sorted_until(first, last, comp, proj) == last;
     }

     template<ranges::forward_range R, class Proj = std::identity,
              std::indirect_strict_weak_order<
                  std::projected<ranges::iterator_t<R>, Proj>>
                      Comp = ranges::less>
     constexpr bool operator()(R&& r, Comp comp = {}, Proj proj = {}) const
     {
         return (*this)(ranges::begin(r), ranges::end(r), std::ref(comp), std::ref(proj));
     }
 };

 inline constexpr is_sorted_fn is_sorted;

.SH Notes

   ranges::is_sorted returns true for empty ranges and ranges of length one.

.SH Example


// Run this code

 #include <algorithm>
 #include <array>
 #include <functional>
 #include <iostream>
 #include <iterator>

 int main()
 {
     namespace ranges = std::ranges;

     std::array digits {3, 1, 4, 1, 5};

     ranges::copy(digits, std::ostream_iterator<int>(std::cout, " "));
     ranges::is_sorted(digits)
         ? std::cout << ": sorted\\n"
         : std::cout << ": not sorted\\n";

     ranges::sort(digits);

     ranges::copy(digits, std::ostream_iterator<int>(std::cout, " "));
     ranges::is_sorted(ranges::begin(digits), ranges::end(digits))
         ? std::cout << ": sorted\\n"
         : std::cout << ": not sorted\\n";

     ranges::reverse(digits);

     ranges::copy(digits, std::ostream_iterator<int>(std::cout, " "));
     ranges::is_sorted(digits, ranges::greater {})
         ? std::cout << ": sorted (with 'greater')\\n"
         : std::cout << ": not sorted\\n";
 }

.SH Output:

 3 1 4 1 5 : not sorted
 1 1 3 4 5 : sorted
 5 4 3 1 1 : sorted (with 'greater')

.SH See also

   ranges::is_sorted_until finds the largest sorted subrange
   (C++20)                 (niebloid)
   is_sorted               checks whether a range is sorted into ascending order
   \fI(C++11)\fP                 \fI(function template)\fP
